\chapter{QAbstractSocket}

QAbstractSocket 类是Qt中 Socket 通信类的基类，被 QTcpSocket 和
QUdpSocket等类继承。QAbstractSocket 类为所有的socket通信类提供了最基本
的功能。

\begin{tabular}{|r|l|}
	\hline
	属性 & 方法 \\
  \hline
	头文件 & \#include <QAbstractSocket>\\      
	\hline
	qmake & QT += network\\      
	\hline
	父类 & QIODevice\\
	\hline
	子类 & QTcpSocket、QUdpSocket \\
	\hline
\end{tabular}

\section{公共成员类型}

\begin{tabular}{|m{5em}|m{35em}|}
\hline
类型&方法 \\ 
\hline
enum&	BindFlag \{ ShareAddress, DontShareAddress, ReuseAddressHint,
      DefaultForPlatform \}\\
\hline
flags&	BindMode\\
\hline
enum&	NetworkLayerProtocol \{ IPv4Protocol, IPv6Protocol, AnyIPProtocol, UnknownNetworkLayerProtocol \}\\
\hline
enum&	PauseMode \{ PauseNever, PauseOnSslErrors \}\\
\hline
flags&	PauseModes\\
\hline
enum&	SocketError \{ ConnectionRefusedError, RemoteHostClosedError, HostNotFoundError, SocketAccessError, SocketResourceError, …, UnknownSocketError \}\\
\hline
enum&	SocketOption \{ LowDelayOption, KeepAliveOption, MulticastTtlOption, MulticastLoopbackOption, TypeOfServiceOption, …, PathMtuSocketOption \}\\
\hline
enum&	SocketState \{ UnconnectedState, HostLookupState, ConnectingState, ConnectedState, BoundState, …, ListeningState \}\\
\hline
enum&	SocketType \{ TcpSocket, UdpSocket, SctpSocket, UnknownSocketType \}\\
  \hline
\end{tabular}

\section{公共成员函数}

\begin{longtable}[l]{|m{15em}|m{27em}|}
\hline
类型&函数名 \\
\hline
	&QAbstractSocket(QAbstractSocket::SocketType socketType, QObject
   *parent)\\
\hline
virtual&	$\sim$QAbstractSocket()\\
\hline
void&	abort()\\
\hline
bool&	bind(const QHostAddress \&address, quint16 port = 0,
QAbstractSocket::BindMode mode = DefaultForPlatform)\\
\hline
bool&	bind(quint16 port = 0, QAbstractSocket::BindMode mode = DefaultForPlatform)\\
\hline
virtual void&	connectToHost(const QString \&hostName, quint16 port,QIODevice::OpenMode
 openMode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)\\
\hline
virtual void &connectToHost(const QHostAddress \&address, quint16 port, QIODevice::Ope
nMode openMode = ReadWrite)\\
\hline
virtual void	&disconnectFromHost()\\
\hline
QAbstractSocket::SocketError & error() const\\
\hline
bool&	flush()\\
\hline
bool&	isValid() const\\
\hline
QHostAddress&	localAddress() const\\
\hline
quint16&	localPort() const\\
\hline
QAbstractSocket::PauseModes	& pauseMode() const\\
\hline
QHostAddress&	peerAddress() const\\
\hline
QString&	peerName() const\\
\hline
quint16&	peerPort() const\\
\hline
QString&	protocolTag() const\\
\hline
QNetworkProxy&	proxy() const\\
\hline
qint64	&readBufferSize() const\\
\hline
virtual void&	resume()\\
\hline
void&	setPauseMode(QAbstractSocket::PauseModes pauseMode)\\
\hline
void&	setProtocolTag(const QString \&tag)\\
\hline
void&	setProxy(const QNetworkProxy \&networkProxy)\\
\hline
virtual void&	setReadBufferSize(qint64 size)\\
\hline
virtual bool&	setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketStat
e socketState = ConnectedState, QIODevice::OpenMode openMode = ReadWrite)\\
\hline
virtual void	&setSocketOption(QAbstractSocket::SocketOption option,
const QVariant \&value)\\
\hline
virtual qintptr&	socketDescriptor() const\\
\hline
virtual QVariant&	socketOption(QAbstractSocket::SocketOption option)\\
\hline
QAbstractSocket::SocketType	&socketType() const\\
\hline
QAbstractSocket::SocketState&	state() const\\
\hline
virtual bool&	waitForConnected(int msecs = 30000)\\
\hline
virtual bool&	waitForDisconnected(int msecs = 30000)\\
\hline
\end{longtable}

\section{重载公共成员函数}

\begin{tabular}{|l|l|}
\hline
类型& 函数名\\ 
\hline
virtual bool&atEnd() const override\\
\hline
virtual qint64&	bytesAvailable() const override\\
\hline
virtual qint64&		bytesToWrite() const override\\
\hline
virtual bool&	canReadLine() const override\\
\hline
virtual void&	close() override\\
\hline
virtual bool&	isSequential() const override\\
\hline
virtual bool&	waitForBytesWritten(int msecs = 30000) override\\
\hline
virtual bool&	waitForReadyRead(int msecs = 30000) override\\
\hline
\end{tabular}

\section{信号}

\begin{tabular}{|m{5em}|m{35em}|}
\hline
类型&函数名 \\
\hline
void&	connected()\\
\hline
void&	disconnected()\\
\hline
void&	errorOccurred(QAbstractSocket::SocketError socketError)\\
\hline
void&	hostFound()\\
\hline
void&	proxyAuthenticationRequired(const QNetworkProxy \&proxy,
                                                          QAuthenticator
                                                          *authenticator)\\
\hline
void&	stateChanged(QAbstractSocket::SocketState socketState)\\
\hline
\end{tabular}

\section{保护成员函数}

\begin{tabular}{|m{5em}|m{35em}|}
\hline
类型&函数名 \\
\hline
void&	setLocalAddress(const QHostAddress \&address)\\
\hline
void&	setLocalPort(quint16 port)\\
\hline
void&	setPeerAddress(const QHostAddress \&address)\\
\hline
void&	setPeerName(const QString \&name)\\
\hline
void&	setPeerPort(quint16 port)\\
\hline
void&	setSocketError(QAbstractSocket::SocketError socketError)\\
\hline
void&	setSocketState(QAbstractSocket::SocketState state)\\
\hline
\end{tabular}

重载保护成员函数

\begin{tabular}{|m{5em}|m{35em}|}
\hline
类型&函数名 \\
\hline
virtual qint64&	readData(char *data, qint64 maxSize) override\\
\hline
virtual qint64&	readLineData(char *data, qint64 maxlen) override\\
\hline
virtual qint64&	writeData(const char *data, qint64 size) override\\
\hline
\end{tabular}

\section{详细介绍}

QAbstractSocket 类是 QTcpSocket 类和 QUdpSocket 类的基类，包含了这两个
类所有的常规功能。您可以通过以下两种方法使用一个套接字( Socket )：

\begin{compactitem}
\item 实例化一个 QTcpSocket 或者 QUdpSocket 对象
\item 声明一个自定义套接字描述符，实例化 QAbstractSocket ，然后调用 setSocketDescriptor() 函数包装该自定义套接字描述符。
\end{compactitem}

TCP（传输控制协议）是一种可靠的，面向流，面向连接的传输协议。 UDP（用户数据报协议）是一种不可靠的，面向数据报的无连接协议。 实际上，这意味着TCP更适合于连续数据传输，而当可靠性不重要时，可以使用更轻量的UDP。

QAbstractSocket 的 API 统一了这两种协议之间的大部分差异。 例如，尽管 UDP 是无连接的，但 connectToHost() 为 UDP 套接字建立了虚拟连接，使您可以忽略底层协议，以几乎相同的方式使用 QAbstractSocket 类。 在 QAbstractSocket 类的内部实现中，QAbstractSocket 记录了传递给 connectToHost() 的地址和端口，并且能在调用 read() 和 write() 之类的成员函数时使用这些值。

任何情况下，QAbstractSocket 类都有一个状态（ state ，该值可以由 state() 成员函数的返回值获得）。 初始状态为未连接（ QAbstractSocket :: UnconnectedState ）状态。 调用 connectToHost() 成员函数连接主机后，套接字会首先进入寻找主机（ QAbstractSocket :: HostLookupState ）状态。 如果找到了主机，则 QAbstractSocket 会进入连接中（ QAbstractSocket :: ConnectingState ）状态，并发送 hostFound() 信号。 建立连接后，它将进入已连接（ QAbstractSocket :: ConnectedState ）状态并发送 connected() 信号。 如果在以上列出任何阶段发生了错误，则会发出 errorOccurred() 信号。 每当状态发生更改时，QAbstractSocket 都会发出 stateChanged() 信号。 为方便起见，当套接字已准备好进行读取和写入数据操作时，isValid() 成员函数的返回值为 true 。但是要注意一下，在进行读写操作之前，套接字的状态必须为已连接（ QAbstractSocket :: ConnectedState ）状态。

您可以通过调用 read() 或 write() 来进行数据读写操作，同时为了方便进行特殊的数据读入操作，您还可以使用 QAbstractSocket 的父类 QIODevice 提供的成员函数 readLine() 和 readAll() 。当我们需要以字节为单位进行数据读写操作时，可以使用 QAbstractSocket 的父类 QIODevice 提供的成员函数 getChar()，putChar() 和 ungetChar() 。 待数据写入套接字后，QAbstractSocket 会发出继承自父类 QIODevice 的信号 bytesWritten() 。请特别注意一下，Qt并不限制写缓冲区的大小。 您可以通过监听 bytesWritten() 信号来监视其大小。

每当有新的数据块到达时，QAbstractSocket 都会发出继承自父类 QIODevice 的信号 readyRead() 。 您可以通过 bytesAvailable() 成员函数的返回值来获得当前读取缓冲区中可读取的字节数。 通常来讲，您可以将 readyRead() 信号与一个槽函数相连接，然后在该槽函数中读取所有可用的数据。 如果您不一次性读取所有数据，则其余数据以后仍可以读取，并且任何新的传入数据都将追加到 QAbstractSocket 的内部读取缓冲区中。您可以通过调用 setReadBufferSize() 成员函数来限制读取缓冲区的大小。

您可以通过调用 disconnectFromHost() 成员函数关闭套接字。 调用 disconnectFromHost() 成员函数后，QAbstractSocket 会进入关闭中（ QAbstractSocket :: ClosingState ）状态。 待所有未处理数据写入套接字后，QAbstractSocket 将关闭套接字，进入未连接（ QAbstractSocket :: UnconnectedState ）状态，并发送 disconnected() 信号。 如果要立即中止连接，并丢弃所有未处理数据，请调用 abort() 成员函数。 如果远程主机关闭了该连接，QAbstractSocket 将发出 errorOccurred(QAbstractSocket :: RemoteHostClosedError) 错误信号，在此期间套接字状态仍为已连接（ QAbstractSocket :: ConnectedState ）状态，此后将发送 disconnected() 信号。

您可以通过调用 peerPort() 和 peerAddress() 成员函数来获取已连接的对等方的端口和地址。 peerName() 成员函数则会返回传递给 connectToHost() 的对等方的主机名。 另外，localPort() 和 localAddress() 成员函数可返回本地套接字的端口和地址。

QAbstractSocket 提供了一组函数，这些函数可以挂起调用线程，直到发出某些
信号为止。 这些函数可用于实现阻塞套接字：

\begin{compactitem}
\item waitForConnected() 阻塞套接字直到一个新的连接建立
\item waitForReadyRead() 阻塞套接字直到有新的数据可以读取
\item waitForBytesWritten() 阻塞套接字直到一个有效的荷载数据写入到了套接字
\item waitForDisconnected() 阻塞套接字直到连接已经关闭
\end{compactitem}



Qt官方提供了如下示例：

\begin{cppcode}
int numRead = 0, numReadTotal = 0;
char buffer[50];

forever {
	numRead  = socket.read(buffer, 50);

	// do whatever with array

	numReadTotal += numRead;
	if (numRead == 0 && !socket.waitForReadyRead())
		break;
}

\end{cppcode}

waitForReadyRead() 成员函数返回值为 false，则说明连接已关闭或发生了错误。

使用阻塞套接字进行编程与使用非阻塞套接字进行编程完全不同。 阻塞套接字不需要有一个事件循环，这通常可以简化代码。 但是，在GUI应用程序中，阻塞套接字只能在非GUI线程中使用，以避免冻结用户界面。 有关这两种方法的概述，请参见 fortuneclien 和 blockingfortuneclient 示例。

\begin{notice}
Qt官方并不推荐将阻塞函数与信号一起使用。
\end{notice}


QAbstractSocket 可以与 QTextStream 和 QDataStream 的流运算符（operator<<() 和operator>>()）一起使用。 但是，有一个问题需要注意：在尝试使用operator>>() 读取数据之前，必须确保有足够的数据可用。

\begin{seeAlso}
QNetworkAccessManager 类和 QTcpServer。
\end{seeAlso}

\splitLine

成员类型文档

enum QAbstractSocket::BindFlag | flags QAbstractSocket::BindMode
该枚举描述了一些不同的标志，这些标志可以传递为 bind() 成员函数的参数，指定了不同的主机绑定模式。

\begin{tabular}{|m{10em}|m{5em}|m{30em}|}
\hline
常量&值&描述 \\
\hline
QAbstractSocket::ShareAddress&	0x1	&允许其他服务绑定到相同的地址和端口。
                               在多个进程通过侦听相同的地址和端口来分
                               担单个服务的负载的情况下（例如，具有多
                               个预分支侦听器的Web服务器可以大大缩短响
                               应时间），该模式十分有效。 但是，由于该
                               模式下允许任何服务对主机进行重新绑定，
                               因此此选项存在着安全隐患。 请注意，您还
                               可以允许您的服务重新绑定现有的共享地址
                               通过将此选项与
                               QAbstractSocket::ReuseAddressHint 结合
                               使用。 在 Unix 上，这等效于
                               SO\_REUSEADDR 套接字选项。 在 Windows 上，
                               这是默认行为，因此将忽略此选项。\\
\hline
QAbstractSocket::DontShareAddress&	0x2&	绑定主机时独占地址和端口，不允
                                   许其他服务重新绑定。 将此选项作为
                                   QAbstractSocket :: bind() 参数，可
                                   以确保在绑定主机成功后，您当前的服
                                   务是唯一侦听指定地址和端口的服务。
                                   即使其他服务通过指定
                                   QAbstractSocket::ReuseAddressHint
                                   模式来绑定服务，这个操作也是不允许
                                   的。 该模式相比
                                   QAbstractSocket::ShareAddress 提供
                                   了更高的安全性，但是在某些操作系统
                                   上，它要求您以管理员权限运行该服务。
                                   在 Unix 和 macOS 上，独占地址和端口
                                   是绑定主机的默认行为，因此该选项将
                                   被忽略。 在 Windows 上，此选项使用
                                   SO\_EXCLUSIVEADDRUSE 套接字选项。\\
\hline
QAbstractSocket::ReuseAddressHint&	0x4	&示意 QAbstractSocket 即使地址
                                   和端口已被另一个套接字绑定，它也应
                                   尝试重新绑定服务。 在 Windows 和
                                   Unix 上，这等效于 SO\_REUSEADDR 套接
                                   字选项。\\
\hline
QAbstractSocket::DefaultForPlatform&	0x0&	使用当前平台的默认模式。 在 Unix 和 macOS 上，这等效于（ QAbstractSocket::DontShareAddress + QAbstractSocket::ReuseAddressHint ），在 Windows 上，它等效于 QAbstractSocket::ShareAddress 。\\
\hline
\end{tabular}

该枚举最初在Qt5.0版本引入。

BindMode 类型是 typedef QFlags <BindFlag> 生成的用户自定义类型。 它存储着 BindFlag 值的 OR 组合。

enum QAbstractSocket::NetworkLayerProtocol

该枚举描述了Qt中可以使用的网络层协议

\begin{tabular}{|m{26em}|m{2em}|m{8em}|}
\hline
常量&值&描述 \\
\hline
QAbstractSocket::IPv4Protocol&	0	&IPv4\\
\hline
QAbstractSocket::IPv6Protocol&	1	&IPv6\\
\hline
QAbstractSocket::AnyIPProtocol&	2	&IPv4 或 IPv6\\
\hline
QAbstractSocket::UnknownNetworkLayerProtocol&	-1	&除IPv4和IPv6之外的协议\\
\hline
\end{tabular}

\begin{seeAlso}
QHostAddress::protocol() 。
\end{seeAlso}

enum QAbstractSocket::PauseMode | flags QAbstractSocket::PauseModes

该枚举描述了套接字在什么情况下该停止传输中的数据。 

当前Qt支持的唯一通知是 QSslSocket::sslErrors()。

\begin{tabular}{|m{19em}|m{2em}|m{18em}|}
%\begin{tabular}{|C{.15\textwidth}|C{.5\textwidth}|C{.15\textwidth}|}}
\hline
常量	&值&	描述\\
\hline
QAbstractSocket::PauseNever&	0x0&	“永远”不暂停套接字上的数据传输。 该模
  式是默认设置，符合Qt 4的标准。\\
\hline
QAbstractSocket::PauseOnSslErrors&	0x1&	收到 SSL 错误（即 QSslSocket::sslErrors() ）的通知后，暂停套接字上的数据传输。\\
\hline
\end{tabular}

该枚举最初在Qt5.0版本引入。

PauseModes 类型是 typedef QFlags<PauseMode> 生成的用户自定义类型。它储存着 PauseMode 值的 OR 组合。

enum QAbstractSocket::SocketError

该枚举描述了常见的套接字错误。

\begin{longtable}[l]{|m{20em}|m{2em}|m{19em}|}
\hline
常量&	值&	描述 \\ 
\hline
QAbstractSocket::ConnectionRefusedError&	0&	连接被对方拒绝（或连接超时）。\\
\hline
QAbstractSocket::RemoteHostClosedError&	1&	远程主机关闭了连接。 请注意，在发送远程
主机连接关闭的通知后，客户端套接字（即此套接字）将被关闭。\\
\hline
QAbstractSocket::HostNotFoundError&	2&	未能找到主机地址。\\
\hline
QAbstractSocket::SocketAccessError&	3&	程序没有权限来进行特定的套接字操作\\
\hline
QAbstractSocket::SocketResourceError&	4&	本地系统资源不足（例如本地系统使用了过多的套接字）。\\
\hline
QAbstractSocket::SocketTimeoutError&	5&	套接字操作超时。\\
\hline
QAbstractSocket::DatagramTooLargeError&	6&	数据报大于操作系统的限制（该限制可以低至
8192字节）。\\
\hline
QAbstractSocket::NetworkError&	7&	网络发生错误（例如网线断开）。\\
\hline
QAbstractSocket::AddressInUseError&	8&	QAbstractSocket::bind() 指定的主机地址已
被另一个套接字使用独占模式绑定。\\
\hline
QAbstractSocket::SocketAddressNotAvailableError&	9& QAbstractSocket::bind() 指定的主机地址不属于主机。\\
\hline
QAbstractSocket::UnsupportedSocketOperationError&	10&	本地操作系统不支持请求的套
接字操作（例如，缺少IPv6支持）。\\
\hline
QAbstractSocket::ProxyAuthenticationRequiredError&	12&	套接字正在使用代理，并且代
理需要身份验证。\\
\hline
QAbstractSocket::SslHandshakeFailedError&	13&	SSL / TLS 握手失败，因此连接已关
闭（仅在 QSslSocket 中使用）。\\
\hline
QAbstractSocket::UnfinishedSocketOperationError&	11&	仅由QAbstractSocketEngine 使用，上一次尝试的操作尚未完成（仍在后台进行）。\\
\hline
QAbstractSocket::ProxyConnectionRefusedError&	14&	代理服务器拒绝了连接。\\
\hline
QAbstractSocket::ProxyConnectionClosedError&	15&	与代理服务器的连接意外关闭（在
建立与对方的最终连接之前）。\\
\hline
QAbstractSocket::ProxyConnectionTimeoutError&	16&	与代理服务器的连接超时或代理服
务器在身份验证阶段停止响应。\\
\hline
QAbstractSocket::ProxyNotFoundError&	17&	找不到使用 setProxy() （或应用程序代理
）设置的代理地址。\\
\hline
QAbstractSocket::ProxyProtocolError&	18&	与代理服务器通信失败，因为无法理解来自代
理服务器的响应，这通常是代理服务协议错误的锅。\\
\hline
QAbstractSocket::OperationError&	19&	套接字所处的状态不允许该操作\\
\hline
QAbstractSocket::SslInternalError&	20&	使用的 SSL 库出现内部错误。 这可能是由于 SS
L 库安装错误或配置错误造成的。\\
\hline
QAbstractSocket::SslInvalidUserDataError&	21&	提供了无效的数据（证书，密钥，密码
等），其使用导致 SSL 库出现错误。\\
\hline
QAbstractSocket::TemporaryError&	22&	发生临时错误（例如，操作将阻塞套接字，而套接
字未阻塞）。\\
\hline
QAbstractSocket::UnknownSocketError&	-1&	神了，出现了一个未知错误。\\
\hline
\end{longtable}

\begin{seeAlso}
QAbstractSocket::error() 和 QAbstractSocket::errorOccurred()。
\end{seeAlso}


\splitLine

enum QAbstractSocket::SocketOption

该枚举表示可以在套接字上设置的选项。 如果需要设置这些选项，您可以在套接字接收到 connectd() 信号之后，或者在 QTcpServer 接收到新的套接字之后，对它们进行设置。

\begin{tabular}{|l|l|l|}
\hline
常量&	值&	描述 \\ 
\hline
QAbstractSocket::LowDelayOption&	0&	尝试优化套接字以降低延迟。 对
                                       于 QTcpSocket ，这将设置
                                       TCP\_NODELAY 选项并禁用 Nagle 的
                                       算法。 将此设置为1启用。\\
\hline
QAbstractSocket::KeepAliveOption&	1&	将此设置为1以启用 SO\_KEEPALIVE 套接字选项\\
\hline
QAbstractSocket::MulticastTtlOption&	2&	将此设置为整数值以设置
                                           IP\_MULTICAST\_TTL （多播数据
                                           报的 TTL ）套接字选项。\\
\hline
QAbstractSocket::MulticastLoopbackOption&	3&	将此设置为1以启用
                                               IP\_MULTICAST\_LOOP （多
                                               播环回）套接字选项。\\
\hline
QAbstractSocket::TypeOfServiceOption&	4&	Windows 不支持此选项。 这
                                           映射到IP\_TOS套接字选项。 有
                                           关其可能的可取值，请参见下
                                           表。\\
\hline
QAbstractSocket::SendBufferSizeSocketOption&	5&	在操作系统级别设置
                                                   套接字发送缓冲区的
                                                   大小（以字节为单位）。
                                                   这映射到 SO\_SNDBUF
                                                   套接字选项。 该选项
                                                   不会影响 QIODevice
                                                   或 QAbstractSocket
                                                   缓冲区。 这个枚举值
                                                   在Qt 5.3中引入。\\
\hline
QAbstractSocket::ReceiveBufferSizeSocketOption&	6&	在操作系统级别设置
                                                   套接字接收缓冲区的
                                                   大小（以字节为单位）。
                                                   这映射到 SO\_RCVBUF
                                                   套接字选项。 此选项
                                                   不会影响 QIODevice
                                                   或 QAbstractSocket
                                                   缓冲区（请参见
                                                   setReadBufferSize()
                                                   ）。 这个枚举值已在
                                                   Qt 5.3中引入。\\
\hline
QAbstractSocket::PathMtuSocketOption&	7	&检索IP堆栈当前已知的路径最大传输单位（ PMTU ）值（如果该值存在）。 一些IP堆栈还允许设置 MTU 进行传输。 这个枚举值在Qt 5.11中引入。\\
\hline
\end{tabular}

TypeOfServiceOption 可能的可取值（优先级）：

\begin{tabular}{|l|l|}
\hline
值&	描述 \\
\hline
224&	Network control（网络控制）\\
\hline
192&	Internetwork control（互联网络控制）\\
\hline
160&	CRITIC/ECP（至关重要）\\
\hline
128&	Flash override（火速覆盖）\\
\hline
96&	Flash（火速）\\
\hline
64&	Immediate（立即）\\
\hline
32&	Priority（主要）\\
\hline
0&	Routine（常规） \\
\hline
\end{tabular}

该枚举最初在Qt4.6版本引入。

\begin{seeAlso}
QAbstractSocket::setSocketOption() 和 QAbstractSocket::socketOption()。
\end{seeAlso}


\splitLine

enum QAbstractSocket::SocketState
该枚举描述了套接字不同的状态。

\begin{tabular}{|l|l|l|}
\hline
常量&	值&	描述 \\ 
\hline
QAbstractSocket::UnconnectedState&	0&	套接字未连接。\\
\hline
QAbstractSocket::HostLookupState&	1&	套接字正在查询主机。\\
\hline
QAbstractSocket::ConnectingState&	2&	套接字开始建立连接。\\
\hline
QAbstractSocket::ConnectedState&	3&	新的连接已建立。\\
\hline
QAbstractSocket::BoundState&	4&	套接字已绑定到一个地址和端口。\\
\hline
QAbstractSocket::ClosingState&	6&	套接字即将关闭（数据可能仍在等待写入）。\\
\hline
QAbstractSocket::ListeningState&	5&	套接字仅限内部使用。\\
\hline
\end{tabular}


\begin{seeAlso}
QAbstractSocket::state()。
\end{seeAlso}

\splitLine

enum QAbstractSocket::SocketType

该枚举描述了传输层的协议。

\begin{tabular}{|l|l|l|}
\hline
常量&	值&	描述 \\ 
\hline
QAbstractSocket::TcpSocket&	0&	TCP \\ 
\hline
QAbstractSocket::UdpSocket&	1&	UDP\\ 
\hline
QAbstractSocket::SctpSocket&	2&	SCTP\\
\hline
QAbstractSocket::UnknownSocketType&	-1&	除 TCP, UDP 和 SCTP 外的协议\\
\hline
\end{tabular}



\begin{seeAlso}
QAbstractSocket::socketType() 。
\end{seeAlso}

\splitLine


\section{成员函数文档}

QAbstractSocket::QAbstractSocket(QAbstractSocket::SocketType
socketType, QObject *parent)

创建一个新抽象套接字 socketType 。 函数中父对象的参数传递给 QObject 的构造函数。

这就是它的构造函数嘛，没啥好说的。另外由于 QAbstractSocket 类继承自 QObject 类，应注意在 QAbstractSocket 类构造函数中调用一下父类 QObject 类的构造函数。


\begin{seeAlso}
socketType() 、 QTcpSocket 和 QUdpSocket 。
\end{seeAlso}


[SIGNAL] void QAbstractSocket::connected()

connectToHost() 调用并成功建立一个连接后，QAbstractSocket 类将发送 connectd() 信号。


\begin{notice}
在某些操作系统上，connected() 信号可能直接从 connectToHost() 调用发出，以连接到本地主机。
\end{notice}


\begin{seeAlso}
connectToHost() 和 disconnected()。
\end{seeAlso}

\splitLine

[SIGNAL] void QAbstractSocket::disconnected()

套接字断开后会发送该信号。

\begin{warning}
如果您想在与这个信号相连接的槽函数中删除信号的发送者（ sender() ），请使用 deleteLater() 函数。
\end{warning}


\begin{seeAlso}
connectToHost() 、disconnectFromHost() 和 abort()。
\end{seeAlso}

\splitLine

[SIGNAL] void
QAbstractSocket::errorOccurred(QAbstractSocket::SocketError
socketError)

当套接字遇到错误时会发送该信号。socketError 参数描述了该错误类型。

发出此信号后，套接字可能并未准备好进行重新连接。 在这种情况下，我们应尝试从事件循环中进行重新连接。 例如我们可以调用一个QTimer::singleShot()，并将0作为时间间隔。

请注意，QAbstractSocket :: SocketError 并不是Qt预注册好的元类型。因此如果您要在队列连接（ queued connections ）模式的信号与槽的连接中传递该类型的参数，您必须使用 Q\_DECLARE\_METATYPE() 和 qRegisterMetaType() 注册它为元类型。

该函数在Qt5.15版本引入。


\begin{seeAlso}
error()、 errorString() 和 Creating Custom Qt Types。
\end{seeAlso}


[SIGNAL] void QAbstractSocket::hostFound()

在 QAbstractSocket 调用 connectToHost() 函数并成功找到主机后，它将发送该消息。

\begin{notice}
从Qt 4.6.3开始，由于可能已缓存DNS结果，因此 QAbstractSocket 可能直接在调用 connectToHost() 时发送 hostFound() 信号。
\end{notice}



\begin{seeAlso}
connectd()。
\end{seeAlso}

[SIGNAL] void QAbstractSocket::proxyAuthenticationRequired(const
QNetworkProxy \&proxy, QAuthenticator *authenticator)

套接字连接的代理服务期需要身份验证时会发送该消息。您可以用所需的详细信息填充 authenticator 对象，以便代理服务期进行身份验证并继续连接。


\begin{notice}
如果信号返回时未使用新信息填充 authenticator ，则连接将失败，因此您不能使用队列连接模式（ QueuedConnection ）连接到该信号。
\end{notice}


该函数首次在Qt4.3版本引入。

\begin{seeAlso}
QAuthenticator 和 QNetworkProxy。
\end{seeAlso}

[SIGNAL] void
QAbstractSocket::stateChanged(QAbstractSocket::SocketState
socketState)

QAbstractSocket 状态发生改变后会发送该信号。socketState 参数记录了新的状态。

\begin{notice}
QAbstractSocket::SocketState 并不是Qt预注册好的元类型。因此如果您要在队列连接（ queued connections ）模式的信号与槽的连接中传递该类型的参数，您必须使用 Q\_DECLARE\_METATYPE() 和 qRegisterMetaType() 注册它为元类型。
\end{notice}


\begin{seeAlso}
state() 和 Create Custom Qt Types 。
\end{seeAlso}


[virtual] QAbstractSocket::$\sim$QAbstractSocket()

析构函数，销毁套接字。

void QAbstractSocket::abort()

中止当前连接并重置套接字。 与 disconnectFromHost() 不同，此函数会立即关闭套接字，并丢弃写缓冲区中的所有未处理数据。



\begin{seeAlso}
 disconnectFromHost() 和 close() 。
\end{seeAlso}

[override virtual] bool QAbstractSocket::atEnd() const

该函数重写了父类 QIODevice 的类成员函数 QIODevice::atEnd() const 。

如果当前没有更多数据可读取，则返回 true ，否则返回 false 。

在循环中从套接字读取数据时，最常使用此功能。 例如：

\begin{cppcode}
// This slot is connected to QAbstractSocket::readyRead()
void SocketClass::readyReadSlot()
{
	while (!socket.atEnd()) {
		QByteArray data = socket.read(100);
		....
	}
}
\end{cppcode}



\begin{seeAlso}
bytesAvailable() 和 readyRead() 。
\end{seeAlso}

\splitLine

bool QAbstractSocket::bind(const QHostAddress \&address, quint16] port
= 0, QAbstractSocket::BindMode mode = DefaultForPlatform)

使用 mode 指定的 QAbstractSocket::BindMode 模式绑定到 address 和 port 指定的地址和端口上。

对于 UDP 套接字来说，在使用 bind() 绑定主机后，只要 UDP 数据报到了达指定的地址和端口，就会发出 QUdpSocket :: readyRead() 的信号。 因此，此功能对于编写UDP服务器很有用。

对于 TCP 套接字来说，此功能可用于指定将哪个接口用于传出连接，这在多个网络接口的情况下很有用。

默认情况下， QAbstractSocket 会使用 DefaultForPlatform BindMode 模式绑定套接字。 如果未指定端口 port ，则 QAbstractSocket 会选择一个随机端口。

成功后，函数返回 true ，套接字进入 已绑定 （ BoundState )状态； 否则返回 false 。

该函数最初在Qt5.0版本引入。

bool QAbstractSocket::bind(quint16 port = 0, QAbstractSocket::BindMode
mode = DefaultForPlatform)

重载 bind() 函数。

该函数会使用 mode 指定的 QAbstractSocket::BindMode 模式绑定到主机上的任何地址（ QHostAddress:Any ) 和 port 指定的端口上。

默认情况下， QAbstractSocket 会使用 DefaultForPlatform BindMode 模式绑定套接字。 如果未指定端口 port ，则 QAbstractSocket 会选择一个随机端口。

该函数最初在Qt5.0版本引入。

[override virtual] qint64 QAbstractSocket::bytesAvailable() const

该函数重写了父类 QIODevice 的类成员函数 QIODevice::bytesAvailable() const 。

返回等待读取的传入字节数。


\begin{seeAlso}
bytesToWrite() 和 read() 。
\end{seeAlso}

[override virtual] qint64 QAbstractSocket::bytesToWrite() const

该函数重写了父类 QIODevice 的类成员函数 QIODevice::bytesToWrite() const 。

返回等待写入的字节数。 当控制权返回事件循环或调用 flush() 时，这些字节将会被写入。



\begin{seeAlso}
 bytesAvailable() 和 flush() 。
\end{seeAlso}

[override virtual] bool QAbstractSocket::canReadLine() const

该函数重写了父类 QIODevice 的类成员函数 QIODevice::canReadLine() const 。

如果能从该套接字中读取一行数据时返回 true，否则返回 false 。



\begin{seeAlso}
readLine() 。
\end{seeAlso}

[override virtual] void QAbstractSocket::close()

该函数重写了父类 QIODevice 的类成员函数 QIODevice::close() 。

关闭套接字的 I/O 设备并调用 disconnectFromHost() 来关闭套接字的连接。

您可以阅读 QIODevice::close() 的介绍来查阅关闭 I/O 设备时发生的操作。


\begin{seeAlso}
abort() 。
\end{seeAlso}


[virtual] void QAbstractSocket::connectToHost(const QString \&hostName,
quint16 port, QIODevice::OpenMode openMode = ReadWrite,
QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)

尝试连接到远程主机 hostname 的给定端口 port 。 protocol 参数可用于指定要使用的网络协议（例如IPv4或IPv6）。

使用 openMode 给定的模式打开套接字并进入 寻找主机（ HostLookupState ）状态，然后 QAbstractSocket 开始执行主机名查找操作。 成功查找到主机名后， QAbstractSocket 会发出 hostFound() 信号，并进入连接中（ ConnectingState ）状态。 接着 QAbstractSocket 会尝试连接到上一部查找主机后返回的一个或多个地址。 最终建立连接后，QAbstractSocket 会进入已连接 （ ConnectedState ）并发送 connectd() 信号。

在以上的任意一阶段中遇到错误，套接字都会发送 errorOccurred() 信号。

hostName 参数可以是一个字符串形式的IP地址（例如"49.195.83.32"），也可以是一个主机名（例如"example.com"）。QAbstractSocket 仅在需要时才会进行查找。 port 端口参数按本机字节顺序。


\begin{seeAlso}
state()、peerName()、peerAddress()、peerPort() 和 waitForConnected()。
\end{seeAlso}

[virtual] void QAbstractSocket::connectToHost(const QHostAddress
\&address, quint16 port, QIODevice::OpenMode openMode = ReadWrite)

重载 connectToHost() 函数。

尝试连接到远程主机 hostname 的给定端口 port 。

[virtual] void QAbstractSocket::disconnectFromHost()

尝试关闭套接字。如果还有未处理的数据等待写入，QAbstractSocket 会进入正在关闭（ ClosingState ）状态并等待所有数据被写入后再关闭套接字。最终 QAbstractSocket 会进入未连接（ UnconnectedState ）状态并发送 disconnected() 信号。


\begin{seeAlso}
connectToHost()。
\end{seeAlso}


QAbstractSocket::SocketError QAbstractSocket::error() const

返回最后一个错误的类型。


\begin{seeAlso}
 state() 和 errorString()。
\end{seeAlso}

bool QAbstractSocket::flush()

该函数尽可能多的在不阻塞套接字的前提下将数据从内部写入缓冲区写入基础网络套接字。 如果写入了任何数据，则此函数返回 true ， 否则返回 false 。

可成功写入的字节数取决于操作系统。请仅在需要 QAbstractSocket 立即开始发送缓冲的数据的情况下调用此函数。 在大多数情况下，您不需要调用此函数，因为一旦控制权返回事件循环，QAbstractSocket 将自动开始发送数据。 在没有事件循环的情况下，请改为调用 waitForBytesWritten() 。



\begin{seeAlso}
 write() 和 waitForBytesWritten()。
\end{seeAlso}

[override virtual] bool QAbstractSocket::isSequential() const

该函数重写了父类 QIODevice 的类成员函数 QIODevice::isSequential() 。

bool QAbstractSocket::isValid() const

如果套接字有效并且可以使用，则返回 true ，否则返回 false 。


\begin{notice}
在进行读写操作之前，套接字必须处于已连接（ ConnectedState ）状态。
\end{notice}


\begin{seeAlso}
 state()。
\end{seeAlso}


QHostAddress QAbstractSocket::localAddress() const

如果本地套接字则可用返回主机地址，否则返回 QHostAddress::Null 。

返回的主机地址通常是主机的IP地址。但是当套接字连接到本地主机时，返回的主机地址为 QHostAddress::LocalAddress。

\begin{seeAlso}
 localPort()、peerAddress() 和 setLocalAddress()。
\end{seeAlso}

quint16 QAbstractSocket::localPort() const

如果本地套接字可用则按照本地字节顺序返回主机端口，否则返回0。


\begin{seeAlso}
 localAddress()，peerPort() 和 setLocalPort()。
\end{seeAlso}


QAbstractSocket::PauseModes QAbstractSocket::pauseMode() const

返回该套接字的数据传输暂停模式。

该函数最初在Qt5.0版本引入。


\begin{seeAlso}
 setPauseMode() 和 resume()。
\end{seeAlso}

QHostAddress QAbstractSocket::peerAddress() const

如果套接字处于已连接（ ConnectedState ）状态则返回对等端的地址，否则返回 QHostAddress::Null 。


\begin{seeAlso}
peerName()，peerPort()，localAddress() 和 setPeerAddress()。
\end{seeAlso}

QString QAbstractSocket::peerName() const

返回在 connectToHost() 函数中指定的主机名。如果 connectToHost() 函数未被调用过则返回一个空的 QString 。


\begin{seeAlso}
peerAddress()，peerPort() 和 setPeerName() 。
\end{seeAlso}



quint16 QAbstractSocket::peerPort() const


如果套接字处于已连接（ ConnectedState ）状态则返回对等端的端口，否则返回0。

\begin{seeAlso}
peerAddress()，localPort() 和 setPeerPort() 。
\end{seeAlso}

QString QAbstractSocket::protocolTag() const

返回此套接字的协议标签。 如果设置了协议标签，则在 QAbstractSocket 内部创建协议标签时将其传递给QNetworkProxyQuery，以指示要使用的协议标签。

该函数最初在Qt5.13版本引入。

\begin{seeAlso}
setProtocolTag() 和 QNetworkProxyQuery  。
\end{seeAlso}

QNetworkProxy QAbstractSocket::proxy() const

返回该套接字的网络代理。默认情况下套接字会使用 QNetworkProxy::DefaultProxy ，套接字会查询应用程序的默认网络代理设置。

该函数最早在Qt4.1版本引入。

\begin{seeAlso}
setProxy() 、 QNetworkProxy 和 QNetworkProxyFactory 。
\end{seeAlso}

qint64 QAbstractSocket::readBufferSize() const

返回内部读取缓冲区的大小。 这限制了客户端在调用 read() 或 readAll() 之前可以接收的数据量。

读取缓冲区大小为0（默认值）意味着缓冲区没有大小限制，从而确保没有数据丢失。

\begin{seeAlso}
setReadBufferSize() 和 read()  。
\end{seeAlso}

[override virtual protected] qint64 QAbstractSocket::readData(char
*data, qint64 maxSize)

该函数重写了父类 QIODevice 的类成员函数 QIODevice::readData() 。

[override virtual protected] qint64 QAbstractSocket::readLineData(char
*data, qint64 maxlen)

该函数重写了父类 QIODevice 的类成员函数 QIODevice::readLineData() 。

[virtual] void QAbstractSocket::resume()

继续套接字数据传输。 仅当将套接字设置为收到暂停的消息后暂停数据传输，并接收到暂停的消息后暂停了数据传输，才能使用此方法。 当前支持的唯一通知是 QSslSocket :: sslErrors() 。 如果套接字未暂停，则调用此方法将导致 未定义的行为（ undefined behavior ）。

该函数最初在Qt5.0版本引入。



\begin{seeAlso}
pauseMode() 和 setPauseMode() 。
\end{seeAlso}

[protected] void QAbstractSocket::setLocalAddress(const QHostAddress
\&address)

将套接字连接中本地的地址设置为 address 。

套接字连接建立后，您可以在 QAbstractSocket 的子类中调用此函数以更改 localAddress() 函数的返回值。 代理连接通常将此功能用于虚拟连接设置。

\begin{notice}
此函数在连接之前不会绑定套接字的本地地址（例如 QAbstractSocket :: bind() ）。
\end{notice}

该函数最初在Qt4.1版本引入。


\begin{seeAlso}
 localAddress()，setLocalPort() 和 setPeerAddress()。
\end{seeAlso}

[protected] void QAbstractSocket::setLocalPort(quint16 port)

将套接字连接中本地的端口设置为 port 。

套接字连接建立后，您可以在 QAbstractSocket 的子类中调用此函数以更改 localPort() 函数的返回值。 代理连接通常将此功能用于虚拟连接设置。

\begin{notice}
此函数在连接之前不会绑定套接字的本地端口（例如 QAbstractSocket :: bind() ）。
\end{notice}

该函数最初在Qt4.1版本引入。

\begin{seeAlso}
localPort()， localAddress()，setLocalPort() 和  setPeerAddress()。
\end{seeAlso}

void QAbstractSocket::setPauseMode(QAbstractSocket::PauseModes
pauseMode)

设置套接字是否在收到通知后暂停数据传输。 pauseMouse 参数指定套接字暂停的条件。目前唯一支持的暂停套接字数据传输的信号是 QSslSocket::sslErrors() 。如果将套接字暂停模式设置为 PauseOnSslErrors ，在接收到 QSslSocket::sslErrors() 信号后套接字上的数据传输将被暂停，并且需要通过调用 resume() 再次显式启用。默认情况下 QAbstractSocket 暂停模式为 PauseNever 。 若要修改暂停模式，您必须在连接服务器前调用此函数，否则对此函数的调用将被视为未定义行为。

该函数最初在Qt5.0版本引入。


\begin{seeAlso}
pauseMode() 和 resume() 。
\end{seeAlso}

[protected] void QAbstractSocket::setPeerAddress(const QHostAddress
\&address)

设将套接字连接中远程的地址设置为 address 。

您可以在 QAbstractSocket 的一个子类中去改变 peerAddress() 函数的返回值。 代理连接通常将此功能用于虚拟连接设置。

该函数最早在Qt4.1版本引入。

\begin{seeAlso}
peerAddress()，setPeerPort() 和 setLocalAddress()。
\end{seeAlso}

[protected] void QAbstractSocket::setPeerName(const QString \&name)

设将套接字连接中远程的主机名设置为 name 。

套接字连接建立后，您可以在 QAbstractSocket 的子类中调用此函数以更改 peerName() 函数的返回值。 代理连接通常将此功能用于虚拟连接设置。

该函数最早在Qt4.1版本引入。


\begin{seeAlso}
 peerName() 。
\end{seeAlso}

[protected] void QAbstractSocket::setPeerPort(quint16 port)

设将套接字连接中远程的端口设置为 port 。

套接字连接建立后，您可以在 QAbstractSocket 的子类中调用此函数以更改 peerPort() 函数的返回值。 代理连接通常将此功能用于虚拟连接设置。

该函数最早在Qt4.1版本引入。


\begin{seeAlso}
peerPort() 。
\end{seeAlso}

void QAbstractSocket::setProtocolTag(const QString \&tag)

将此套接字的协议标签设置为 tag 。

该函数最早在Qt5.13版本引入。


\begin{seeAlso}
protocolTag() 。
\end{seeAlso}

void QAbstractSocket::setProxy(const QNetworkProxy \&networkProxy )

将此套接字的显式网络代理设置为 networkProxy 。

您可以通过指定 networkProxy 为 QNetworkProxy::NoProxy 以禁止套接字使用代理网络：


\begin{cppcode}
socket->setProxy(QNetworkProxy::NoProxy);
\end{cppcode}


套接字默认使用的代理为 QNetworkProxy::DefaultProxy 即套接字会使用应用程序的代理设置，将代理设置为 QNetworkProxy::setApplicationProxy 也可以达到同样的效果。如果您使用 QNetworkProxyFactory :: setApplicationProxyFactory 设置了 QNetworkProxy 插件工厂，它将使用 QNetworkProxyQuery :: TcpSocket 类型查询该插件工厂。

该函数最早在Qt4.1版本引入。


\begin{seeAlso}
proxy() 、 QNetworkProxy 和 QNetworkProxyFactory::queryProxy() 。
\end{seeAlso}


[virtual] void QAbstractSocket::setReadBufferSize(qint64 size)

设置 QAbstractSocket 内部读入缓冲区的大小（字节为单位）。

如果将该缓冲区的大小设置为一个确定的值，QAbstractSocket 内部读入缓冲区内的值大小超过该值后，便不会再缓冲数据。与此相反，缓冲区大小为0意味着读缓冲区不受限制，所有传入数据都将被缓冲，同时这也是默认值。

该功能在特定的情况下（例如，在实时流应用程序中）读取数据，或者要保护套接字避免接收过多的数据（可能最终导致应用程序用尽内存）很有用。

只有QTcpSocket使用 QAbstractSocket 的内部缓冲区。 QUdpSocket 根本不使用任何缓冲，而是依赖于操作系统提供的隐式缓冲。 因此，在 QUdpSocket 上调用此函数无效。


\begin{seeAlso}
readBufferSize() 和 read()  。
\end{seeAlso}

[virtual] bool QAbstractSocket::setSocketDescriptor(qintptr
socketDescriptor, QAbstractSocket::SocketState socketState =
ConnectedState, QIODevice::OpenMode openMode = ReadWrite)

使用本机套接字描述符 socketDescriptor 初始化 QAbstractSocket 。 如果 socketDescriptor 为有效的套接字描述符，则返回 true ，否则返回 false 。 套接字以 openMode 指定的模式打开，并进入由 socketState 指定的套接字状态。 读取和写入缓冲区将会丢弃所有未决数据并清空。

\begin{notice}
 无法使用相同的本机套接字描述符初始化两个抽象套接字。
\end{notice}

\begin{seeAlso}
socketDescriptor()。
\end{seeAlso}


[proteched] void
QAbstractSocket::setSocketError(QAbstractSocket::SocketError
socketError)

将套接字最后一个出现的错误的类型设置为 socketError 。


\begin{seeAlso}
setSocketState() 和 setErrorString() 。
\end{seeAlso}

[virtual] void
QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option,
const QVariant \&value)

将 option 指定的套接字选项设置为 value 指定的值。

\begin{notice}
当应用程序在 Windows 下运行时， QAbstractSocket::KeepAliveOption 选项的值必须在套接字连接之前指定。
\end{notice}

该函数最初在Qt4.6版本引入。


\begin{seeAlso}
socketOption()。
\end{seeAlso}

[protected] void QAbstractSocket::setSocketState(QAbstractSocket::SocketState state)
将套接字的状态设置为 state 。


\begin{seeAlso}
state()。
\end{seeAlso}

[virtual] qintptr QAbstractSocket::socketDescriptor() const

当 QAbstractSocket 类对象的本地套接字描述符可用时，则返回该描述符，否则返回-1。

如果套接字使用了网络代理，则返回的描述符可能无法与本机套接字一起使用。

当 QAbstractSocket 类处于未连接（UnconnectedState）状态时，该描述符是不可用的。


\begin{seeAlso}
setSocketDescriptor()。
\end{seeAlso}


[virtual] QVariant
QAbstractSocket::socketOption(QAbstractSocket::SocketOption) option)

返回 option 指定的套接字选项的值。

该函数最早在Qt4.6版本引入。



\begin{seeAlso}
setSocketDescriptor() 。
\end{seeAlso}

QAbstractSocket::SocketType QAbstractSocket::socketType() const

返回套接字类型（ TCP，UDP，或者其他）。

\begin{seeAlso}
QTcpSocket 和 QUdpSocket。
\end{seeAlso}



QAbstractSocket::SocketState QAbstractSocket::state() const

返回套接字的当前状态。


\begin{seeAlso}
error() 。
\end{seeAlso}

[override virtual] bool QAbstractSocket::waitForBytesWritten(int msecs
= 30000)

该函数重写了父类 QIODevice 的类成员函数 QIODevice::waitForBytesWritten(int msecs) 。

该函数将阻塞套接字通信直到至少一个字节被写入到套接字并发送 bytesWritten() 信号为止。 函数将会在 msecs 指定的时间后超时，默认的超时时间设置为30000毫秒。

bytesWritten() 信号发出后该函数返回值为 true，偶则返回 false （如果有一个错误发生或者该操作超时）。

\begin{notice}
在 Windows 上，此功能可能会随机性地失败。 如果您的软件将在 Windows 上运行，请考虑使用事件循环和 bytesWritten() 信号。
\end{notice}

\begin{seeAlso}
waitForReadyRead()。
\end{seeAlso}

[virtual] bool QAbstractSocket::waitForConnected(int msecs = 30000)

在 msecs 指定的时间内等待套接字连接到主机。如果连接成功建立，则返回 true ，否则返回 false 。如果该函数返回 false ，您可以调用 error() 函数来确定连接中出现的错误的类型。

这里Qt官方给了一个1秒内等待套接字建立到主机的连接的示例：


\begin{cppcode}
socket->connectToHost("imap", 143);
if (socket->waitForConnected(1000))
	qDebug("Connected!");
\end{cppcode}

如果将 msecs 设置为-1，这个函数将不会超时。

\begin{notice}
由于套接字完成主机的查询需要一定时间，这个函数超时的时间可能会比 msecs 设定的时间要轻微的长一些。
\end{notice}


\begin{notice}
多次调用这个函数并不会累积超时时间。如果函数超时，套接字的连接进程就会被中断。
\end{notice}

\begin{notice}
在 Windows 上，此功能可能会随机性地失败。 如果您的软件将在 Windows 上运行，请考虑使用事件循环和 connected() 信号。
\end{notice}



\begin{seeAlso}
connectToHost() 和 connected()。
\end{seeAlso}

\splitLine

[virtual] bool QAbstractSocket::waitForDisconnected(int msecs = 30000)

在 msecs 指定的时间内等待套接字从主机断开连接。 如果连接成功断开，则返回 true ，否则返回 false （操作超时，出现错误，或者已经断开连接）。 如果该函数返回 false ，您可以调用 error() 函数来确定断开连接时出现的错误的类型。

这里Qt官方给了一个1秒内等待套接字从主机断开连接的示例：

\begin{cppcode}
socket->disconnectFromHost();
if (socket->state() == QAbstractSocket::UnconnectedState
	|| socket->waitForDisconnected(1000)) {
		qDebug("Disconnected!");
 }
\end{cppcode}

如果 msecs 设为-1，该函数将不会超时。

\begin{notice}
在 Windows 上，此功能可能会随机性地失败。 如果您的软件将在 Windows 上运行，请考虑使用事件循环和 disconnected() 信号。
\end{notice}




\begin{seeAlso}
disconnectFromHost() 和 close() 。
\end{seeAlso}

\splitLine

[override virtual] bool QAbstractSocket::waitForReadyRead(int msecs =
30000)

该函数重写了父类 QIODevice 的类成员函数 QIODevice::waitForReadyRead(int msecs) 。

该函数将阻塞套接字通信直到有新的字节可以读取并发送 readyRead() 信号为止。 函数将会在 msecs 指定的时间后超时，默认的超时时间设置为30000毫秒。

readyRead() 信号发出后该函数返回值为 true，偶则返回 false （如果有一个错误发生或者该操作超时）。

\begin{notice}
在 Windows 上，此功能可能会随机性地失败。 如果您的软件将在 Windows 上运行，请考虑使用事件循环和 readyRead() 信号。
\end{notice}


\begin{seeAlso}
waitForBytesWritten()。
\end{seeAlso}


\splitLine

[overrude virtual protected] qint64 QAbstractSocket::writeData(const char *data, qint64 size)

该函数重写了父类 QIODevice 的类成员函数 QIODevice::writeData(const
char data, qint64 size)。
